typedef enum cexpr_operator
{
- CEXPR_EQ, // equal
- CEXPR_NE, // not equal
- CEXPR_GT, // greater than
- CEXPR_LT, // less than
- CEXPR_GE, // greater than or equal to
- CEXPR_LE, // less than or equal to
- CEXPR_IN, // contains (string)
- CEXPR_NI, // not contains (string)
+ CEXPR_EQ, /* equal */
+ CEXPR_NE, /* not equal */
+ CEXPR_GT, /* greater than */
+ CEXPR_LT, /* less than */
+ CEXPR_GE, /* greater than or equal to */
+ CEXPR_LE, /* less than or equal to */
+ CEXPR_IN, /* contains (string) */
+ CEXPR_NI, /* not contains (string) */
CEXPR_AND,
CEXPR_OR,
} cexpr_operator_t;
typedef struct cexpr_s
{
- cexpr_operator_t operator; // AND/OR
+ cexpr_operator_t operator; /* AND/OR */
int8_t tp_a;
int8_t tp_b;
cexpr_via_t via_a;
* Values with -##- will never be returned while unpacking. For example
* a QP_INT8 (1 byte signed integer) will be returned as QP_INT64.
*/
- QP_END, // at the end while unpacking
- QP_ERR, // error
- QP_RAW, // raw string
+ QP_END, /* at the end while unpacking */
+ QP_ERR, /* error */
+ QP_RAW, /* raw string */
/*
* Both END and RAW are never actually packed but 0 and 1 are reserved
* for positive signed integers.
* Fixed negative integers from -60 till -1 [ 64...123 ]
*
*/
- QP_HOOK=124, // Hook is not used by SiriDB
- QP_DOUBLE_N1=125, // ## double value -1.0
- QP_DOUBLE_0, // ## double value 0.0
- QP_DOUBLE_1, // ## double value 1.0
+ QP_HOOK=124, /* Hook is not used by SiriDB */
+ QP_DOUBLE_N1=125, /* ## double value -1.0 */
+ QP_DOUBLE_0, /* ## double value 0.0 */
+ QP_DOUBLE_1, /* ## double value 1.0 */
/*
* Fixed raw strings lengths from 0 till 99 [ 128...227 ]
*/
- QP_RAW8=228, // ## raw string with length < 1 byte
- QP_RAW16, // ## raw string with length < 1 byte
- QP_RAW32, // ## raw string with length < 1 byte
- QP_RAW64, // ## raw string with length < 1 byte
- QP_INT8, // ## 1 byte signed integer
- QP_INT16, // ## 2 byte signed integer
- QP_INT32, // ## 4 byte signed integer
- QP_INT64, // 8 bytes signed integer
- QP_DOUBLE, // 8 bytes double
- QP_ARRAY0, // empty array
- QP_ARRAY1, // array with 1 item
- QP_ARRAY2, // array with 2 items
- QP_ARRAY3, // array with 3 items
- QP_ARRAY4, // array with 4 items
- QP_ARRAY5, // array with 5 items
- QP_MAP0, // empty map
- QP_MAP1, // map with 1 item
- QP_MAP2, // map with 2 items
- QP_MAP3, // map with 3 items
- QP_MAP4, // map with 4 items
- QP_MAP5, // map with 5 items
- QP_TRUE, // boolean true
- QP_FALSE, // boolean false
- QP_NULL, // null (none, nil)
- QP_ARRAY_OPEN, // open a new array
- QP_MAP_OPEN, // open a new map
- QP_ARRAY_CLOSE, // close array
- QP_MAP_CLOSE, // close map
+ QP_RAW8=228, /* ## raw string with length < 1 byte */
+ QP_RAW16, /* ## raw string with length < 1 byte */
+ QP_RAW32, /* ## raw string with length < 1 byte */
+ QP_RAW64, /* ## raw string with length < 1 byte */
+ QP_INT8, /* ## 1 byte signed integer */
+ QP_INT16, /* ## 2 byte signed integer */
+ QP_INT32, /* ## 4 byte signed integer */
+ QP_INT64, /* 8 bytes signed integer */
+ QP_DOUBLE, /* 8 bytes double */
+ QP_ARRAY0, /* empty array */
+ QP_ARRAY1, /* array with 1 item */
+ QP_ARRAY2, /* array with 2 items */
+ QP_ARRAY3, /* array with 3 items */
+ QP_ARRAY4, /* array with 4 items */
+ QP_ARRAY5, /* array with 5 items */
+ QP_MAP0, /* empty map */
+ QP_MAP1, /* map with 1 item */
+ QP_MAP2, /* map with 2 items */
+ QP_MAP3, /* map with 3 items */
+ QP_MAP4, /* map with 4 items */
+ QP_MAP5, /* map with 5 items */
+ QP_TRUE, /* boolean true */
+ QP_FALSE, /* boolean false */
+ QP_NULL, /* null (none, nil) */
+ QP_ARRAY_OPEN, /* open a new array */
+ QP_MAP_OPEN, /* open a new map */
+ QP_ARRAY_CLOSE, /* close array */
+ QP_MAP_CLOSE, /* close map */
} qp_types_t;
typedef union qp_via_u
typedef struct qp_unpacker_s
{
- unsigned char * source; // can be NULL or a copy or the source
+ unsigned char * source; /* can be NULL or a copy or the source */
unsigned char * pt;
unsigned char * end;
} qp_unpacker_t;
} qp_packer_t;
typedef FILE qp_fpacker_t;
-#define qp_open fopen // returns NULL in case of an error
-#define qp_close fclose // 0 if successful, EOF in case of an error
-#define qp_flush fflush // 0 if successful, EOF in case of an error
+#define qp_open fopen /* returns NULL in case of an error */
+#define qp_close fclose /* 0 if successful, EOF in case of an error */
+#define qp_flush fflush /* 0 if successful, EOF in case of an error */
/* packer: create, destroy and extend functions */
qp_packer_t * qp_packer_new(size_t alloc_size);
uint16_t pid;
uint16_t port;
uuid_t uuid;
- int pool; // -1 for a new pool
+ int pool; /* -1 for a new pool */
char * host;
char * username;
char * password;
uint64_t group_by;
uint64_t limit;
uint64_t offset;
- double timespan; // used for derivative
+ double timespan; /* used for derivative */
pcre2_code * regex; \
pcre2_match_data * match_data;
qp_via_t filter_via;
#include <siri/db/tasks.h>
#define SIRIDB_MAX_SIZE_ERR_MSG 1024
-#define SIRIDB_MAX_DBNAME_LEN 256 // 255 + NULL
+#define SIRIDB_MAX_DBNAME_LEN 256 /* 255 + NULL */
#define SIRIDB_SCHEMA 3
#define SIRIDB_FLAG_REINDEXING 1
-#define DEF_DROP_THRESHOLD 1.0 // 100%
-#define DEF_SELECT_POINTS_LIMIT 1000000 // one million
-#define DEF_LIST_LIMIT 10000 // ten thousand
+#define DEF_DROP_THRESHOLD 1.0 /* 100% */
+#define DEF_SELECT_POINTS_LIMIT 1000000 /* one million */
+#define DEF_LIST_LIMIT 10000 /* ten thousand */
#define SIRIDB_GET_FN(FN, __path, FILENAME) \
char FN[strlen(__path) + strlen(FILENAME) + 1]; \
iso8601_tz_t tz;
size_t buffer_size;
size_t buffer_len;
- struct timespec start_time; // to calculate up-time.
- uint64_t duration_num; // number duration in s, ms, us or ns
- uint64_t duration_log; // log duration in s, ms, us or ns
+ struct timespec start_time; /* to calculate up-time. */
+ uint64_t duration_num; /* number duration in s, ms, us or ns */
+ uint64_t duration_log; /* log duration in s, ms, us or ns */
char * dbname;
char * dbpath;
char * buffer_path;
uint64_t id;
char * fn;
uint32_t free_space;
- uint32_t next_size; // must be uint32_t (4 bytes)
+ uint32_t next_size; /* must be uint32_t (4 bytes) */
FILE * fp;
int fd;
long int size;
llist_t * fifos;
siridb_ffile_t * in;
siridb_ffile_t * out;
- ssize_t max_id; // max_id can be -1
+ ssize_t max_id; /* max_id can be -1 */
} siridb_fifo_t;
ERR_EXPECTING_AT_LEAST_ONE_POINT,
ERR_EXPECTING_NAME_AND_POINTS,
ERR_INCOMPATIBLE_SERVER_VERSION,
- ERR_MEM_ALLOC, // This is a critical error.
+ ERR_MEM_ALLOC, /* This is a critical error. */
} siridb_insert_err_t;
enum
*/
typedef enum
{
- SIRIDB_QUERY_FWD_SERVERS, // Forward to all 'online' servers
- SIRIDB_QUERY_FWD_POOLS, // Forward to all pools(*)
- SIRIDB_QUERY_FWD_SOME_POOLS, // Forward to some pools(*)
- SIRIDB_QUERY_FWD_UPDATE // Forward to all pools, update replicas(*)
+ SIRIDB_QUERY_FWD_SERVERS, /* Forward to all 'online' servers */
+ SIRIDB_QUERY_FWD_POOLS, /* Forward to all pools(*) */
+ SIRIDB_QUERY_FWD_SOME_POOLS, /* Forward to some pools(*) */
+ SIRIDB_QUERY_FWD_UPDATE /* Forward to all pools, upd repl(*) */
} siridb_query_fwd_t;
and will NEVER be set on 'this'
server */
-#define SERVER__IS_ONLINE 65 // RUNNING + AUTHENTICATED
-#define SERVER__IS_SYNCHRONIZING 67 // RUNNING + SYNCHRONIZING + AUTHENTICATED
-#define SERVER__IS_REINDEXING 69 // RUNNING + REINDEXING + AUTHENTICATED
+/* RUNNING + AUTHENTICATED */
+#define SERVER__IS_ONLINE 65
-#define SERVER__SELF_ONLINE 1 // RUNNING
-#define SERVER__SELF_SYNCHRONIZING 3 // RUNNING + SYNCHRONIZING
-#define SERVER__SELF_REINDEXING 5 // RUNNING + REINDEXING
+/* RUNNING + SYNCHRONIZING + AUTHENTICATED */
+#define SERVER__IS_SYNCHRONIZING 67
+
+/* RUNNING + REINDEXING + AUTHENTICATED */
+#define SERVER__IS_REINDEXING 69
+
+#define SERVER__SELF_ONLINE 1 /* RUNNING */
+#define SERVER__SELF_SYNCHRONIZING 3 /* RUNNING + SYNCHRONIZING */
+#define SERVER__SELF_REINDEXING 5 /* RUNNING + REINDEXING */
/*
#define SIRIDB_SHARD_IS_CORRUPT 64
#define SIRIDB_SHARD_IS_COMPRESSED 128
-// HAS_OVERLAP + HAS_NEW_VALUES + HAS_DROPPED_SERIES + IS_CORRUPT
+/* HAS_OVERLAP + HAS_NEW_VALUES + HAS_DROPPED_SERIES + IS_CORRUPT */
#define SIRIDB_SHARD_NEED_OPTIMIZE 78
/* types */
cleri_grammar_t * compile_grammar(void);
enum cleri_grammar_ids {
- CLERI_NONE, // used for objects with no name
+ CLERI_NONE, /* used for objects with no name */
CLERI_GID_ACCESS_EXPR,
CLERI_GID_ACCESS_KEYWORDS,
CLERI_GID_AFTER_EXPR,
CLERI_GID_WHERE_SHARD,
CLERI_GID_WHERE_USER,
CLERI_GID__BOOLEAN,
- CLERI_END // can be used to get the enum length
+ CLERI_END /* can be used to get the enum length */
};
#endif /* CLERI_EXPORT_SIRI_GRAMMAR_GRAMMAR_H_ */
typedef struct sirinet_pkg_s
{
- uint32_t len; // length of data, sizeof(sirinet_pkg_t) is not included
+ uint32_t len; /* length of data, sizeof(sirinet_pkg_t) is not included */
uint16_t pid;
uint8_t tp;
uint8_t checkbit;
#include <siri/db/server.h>
#include <siri/net/pkg.h>
-#define PROMISE_DEFAULT_TIMEOUT 30000 // 30 seconds
+#define PROMISE_DEFAULT_TIMEOUT 30000 /* 30 seconds */
typedef struct siridb_server_s siridb_server_t;
typedef struct sirinet_promise_s sirinet_promise_t;
typedef enum
{
- PROMISE_TIMEOUT_ERROR=-4, // in case of a time out
- PROMISE_WRITE_ERROR, // socket write error
- PROMISE_CANCELLED_ERROR, // timer is cancelled
- PROMISE_PKG_TYPE_ERROR, // unexpected package type received
+ PROMISE_TIMEOUT_ERROR=-4, /* in case of a time out */
+ PROMISE_WRITE_ERROR, /* socket write error */
+ PROMISE_CANCELLED_ERROR, /* timer is cancelled */
+ PROMISE_PKG_TYPE_ERROR, /* unexpected package type received */
PROMISE_SUCCESS=0
} sirinet_promise_status_t;
typedef enum
{
- CPROTO_REQ_QUERY, // (query, time_precision)
- CPROTO_REQ_INSERT, // series with points map/array
- CPROTO_REQ_AUTH, // (user, password, dbname)
- CPROTO_REQ_PING, // empty
- CPROTO_REQ_INFO, // empty
- CPROTO_REQ_LOADDB, // database path
- CPROTO_REQ_REGISTER_SERVER, // (uuid, host, port, pool)
- CPROTO_REQ_FILE_SERVERS, // empty
- CPROTO_REQ_FILE_USERS, // empty
- CPROTO_REQ_FILE_GROUPS, // empty
- CPROTO_REQ_FILE_DATABASE, // empty
+ CPROTO_REQ_QUERY, /* (query, time_precision) */
+ CPROTO_REQ_INSERT, /* series with points map/array */
+ CPROTO_REQ_AUTH, /* (user, password, dbname) */
+ CPROTO_REQ_PING, /* empty */
+ CPROTO_REQ_INFO, /* empty */
+ CPROTO_REQ_LOADDB, /* database path */
+ CPROTO_REQ_REGISTER_SERVER, /* (uuid, host, port, pool) */
+ CPROTO_REQ_FILE_SERVERS, /* empty */
+ CPROTO_REQ_FILE_USERS, /* empty */
+ CPROTO_REQ_FILE_GROUPS, /* empty */
+ CPROTO_REQ_FILE_DATABASE, /* empty */
/* Administrative API request */
- CPROTO_REQ_ADMIN=32, // (user, password, request, {...})
+ CPROTO_REQ_ADMIN=32, /* (user, password, request, {...}) */
} cproto_client_t;
typedef enum
{
/* success */
- CPROTO_RES_QUERY, // {query response data}
- CPROTO_RES_INSERT, // {"success_msg": ...}
- CPROTO_RES_AUTH_SUCCESS, // empty
- CPROTO_RES_ACK, // empty
- CPROTO_RES_INFO, // [version, [dnname1, ...]]
- CPROTO_RES_FILE, // file content
+ CPROTO_RES_QUERY, /* {query response data} */
+ CPROTO_RES_INSERT, /* {"success_msg": ...} */
+ CPROTO_RES_AUTH_SUCCESS, /* empty */
+ CPROTO_RES_ACK, /* empty */
+ CPROTO_RES_INFO, /* [version, [dnname1, ...]] */
+ CPROTO_RES_FILE, /* file content */
/* Administrative API success */
- CPROTO_ACK_ADMIN=32, // empty
- CPROTO_ACK_ADMIN_DATA, // [...]
+ CPROTO_ACK_ADMIN=32, /* empty */
+ CPROTO_ACK_ADMIN_DATA, /* [...] */
/* errors 64-69 are errors with messages */
- CPROTO_ERR_MSG=64, // {"error_msg": ...}
- CPROTO_ERR_QUERY, // {"error_msg": ...}
- CPROTO_ERR_INSERT, // {"error_msg": ...}
- CPROTO_ERR_SERVER, // {"error_msg": ...}
- CPROTO_ERR_POOL, // {"error_msg": ...}
- CPROTO_ERR_USER_ACCESS, // {"error_msg": ...}
- CPROTO_ERR, // empty (use for unexpected errors)
- CPROTO_ERR_NOT_AUTHENTICATED, // empty
- CPROTO_ERR_AUTH_CREDENTIALS, // empty
- CPROTO_ERR_AUTH_UNKNOWN_DB, // empty
- CPROTO_ERR_LOADING_DB, // empty
- CPROTO_ERR_FILE, // empty
+ CPROTO_ERR_MSG=64, /* {"error_msg": ...} */
+ CPROTO_ERR_QUERY, /* {"error_msg": ...} */
+ CPROTO_ERR_INSERT, /* {"error_msg": ...} */
+ CPROTO_ERR_SERVER, /* {"error_msg": ...} */
+ CPROTO_ERR_POOL, /* {"error_msg": ...} */
+ CPROTO_ERR_USER_ACCESS, /* {"error_msg": ...} */
+ CPROTO_ERR, /* empty (use for unexpected errors)*/
+ CPROTO_ERR_NOT_AUTHENTICATED, /* empty */
+ CPROTO_ERR_AUTH_CREDENTIALS, /* empty */
+ CPROTO_ERR_AUTH_UNKNOWN_DB, /* empty */
+ CPROTO_ERR_LOADING_DB, /* empty */
+ CPROTO_ERR_FILE, /* empty */
/* Administrative API errors */
- CPROTO_ERR_ADMIN=96, // {"error_msg": ...}
- CPROTO_ERR_ADMIN_INVALID_REQUEST, // empty
- CPROTO_DEFERRED=127 // deferred...
+ CPROTO_ERR_ADMIN=96, /* {"error_msg": ...} */
+ CPROTO_ERR_ADMIN_INVALID_REQUEST, /* empty */
+ CPROTO_DEFERRED=127 /* deferred... */
} cproto_server_t;
typedef enum
{
- BPROTO_AUTH_REQUEST=128, /* (uuid, dbname, flags, version,
- min_version, dbpath, buffer_path,
- buffer_size, startup_time,
- address, port) */
- BPROTO_FLAGS_UPDATE, // flags
- BPROTO_LOG_LEVEL_UPDATE, // log_level
- BPROTO_REPL_FINISHED, // empty
- BPROTO_QUERY_SERVER, // (query, time_precision)
- BPROTO_QUERY_UPDATE, // (query, time_precision)
- BPROTO_INSERT_POOL, // {series: points, ...}
- BPROTO_INSERT_SERVER, // {series: points, ...}
- BPROTO_INSERT_TEST_POOL, // {series: points, ...}
- BPROTO_INSERT_TEST_SERVER, // {series: points, ...}
- BPROTO_INSERT_TESTED_POOL, // {series: points, ...}
- BPROTO_INSERT_TESTED_SERVER, // {series: points, ...}
- BPROTO_REGISTER_SERVER, // (uuid, host, port, pool)
- BPROTO_DROP_SERIES, // series_name
- BPROTO_REQ_GROUPS, // empty
- BPROTO_ENABLE_BACKUP_MODE, // empty
- BPROTO_DISABLE_BACKUP_MODE, // empty
+ BPROTO_AUTH_REQUEST=128, /* (uuid, dbname, flags, version,
+ min_version, dbpath, buffer_path,
+ buffer_size, startup_time,
+ address, port) */
+ BPROTO_FLAGS_UPDATE, /* flags */
+ BPROTO_LOG_LEVEL_UPDATE, /* log_level */
+ BPROTO_REPL_FINISHED, /* empty */
+ BPROTO_QUERY_SERVER, /* (query, time_precision) */
+ BPROTO_QUERY_UPDATE, /* (query, time_precision) */
+ BPROTO_INSERT_POOL, /* {series: points, ...} */
+ BPROTO_INSERT_SERVER, /* {series: points, ...} */
+ BPROTO_INSERT_TEST_POOL, /* {series: points, ...} */
+ BPROTO_INSERT_TEST_SERVER, /* {series: points, ...} */
+ BPROTO_INSERT_TESTED_POOL, /* {series: points, ...} */
+ BPROTO_INSERT_TESTED_SERVER, /* {series: points, ...} */
+ BPROTO_REGISTER_SERVER, /* (uuid, host, port, pool) */
+ BPROTO_DROP_SERIES, /* series_name */
+ BPROTO_REQ_GROUPS, /* empty */
+ BPROTO_ENABLE_BACKUP_MODE, /* empty */
+ BPROTO_DISABLE_BACKUP_MODE, /* empty */
} bproto_client_t;
/*
{
/* Mappings to client protocol messages */
/* success */
- BPROTO_RES_QUERY=CPROTO_RES_QUERY, // {query response data}
+ BPROTO_RES_QUERY=CPROTO_RES_QUERY, /* {query response data} */
/* errors */
- BPROTO_ERR_QUERY=CPROTO_ERR_QUERY, // {"error_msg": ...}
- BPROTO_ERR_SERVER=CPROTO_ERR_SERVER, // {"error_msg": ...}
- BPROTO_ERR_POOL=CPROTO_ERR_POOL, // {"error_msg": ...}
+ BPROTO_ERR_QUERY=CPROTO_ERR_QUERY, /* {"error_msg": ...} */
+ BPROTO_ERR_SERVER=CPROTO_ERR_SERVER, /* {"error_msg": ...} */
+ BPROTO_ERR_POOL=CPROTO_ERR_POOL, /* {"error_msg": ...} */
/* Back-end specific protocol messages */
/* errors */
- BPROTO_AUTH_ERR_UNKNOWN_UUID=128, // empty
- BPROTO_AUTH_ERR_UNKNOWN_DBNAME, // empty
- BPROTO_AUTH_ERR_INVALID_UUID, // empty
- BPROTO_AUTH_ERR_VERSION_TOO_OLD, // empty
- BPROTO_AUTH_ERR_VERSION_TOO_NEW, // empty
- BPROTO_ERR_NOT_AUTHENTICATED, // empty
- BPROTO_ERR_INSERT, // empty
- BPROTO_ERR_REGISTER_SERVER, // empty
- BPROTO_ERR_DROP_SERIES, // empty
- BPROTO_ERR_ENABLE_BACKUP_MODE, // empty
- BPROTO_ERR_DISABLE_BACKUP_MODE, // empty
+ BPROTO_AUTH_ERR_UNKNOWN_UUID=128, /* empty */
+ BPROTO_AUTH_ERR_UNKNOWN_DBNAME, /* empty */
+ BPROTO_AUTH_ERR_INVALID_UUID, /* empty */
+ BPROTO_AUTH_ERR_VERSION_TOO_OLD, /* empty */
+ BPROTO_AUTH_ERR_VERSION_TOO_NEW, /* empty */
+ BPROTO_ERR_NOT_AUTHENTICATED, /* empty */
+ BPROTO_ERR_INSERT, /* empty */
+ BPROTO_ERR_REGISTER_SERVER, /* empty */
+ BPROTO_ERR_DROP_SERIES, /* empty */
+ BPROTO_ERR_ENABLE_BACKUP_MODE, /* empty */
+ BPROTO_ERR_DISABLE_BACKUP_MODE, /* empty */
/* success */
- BPROTO_AUTH_SUCCESS=192, // empty
- BPROTO_ACK_FLAGS, // empty
- BPROTO_ACK_LOG_LEVEL, // empty
- BPROTO_ACK_INSERT, // empty
- BPROTO_ACK_REPL_FINISHED, // empty
- BPROTO_ACK_REGISTER_SERVER, // empty
- BPROTO_ACK_DROP_SERIES, // empty
- BPROTO_ACK_ENABLE_BACKUP_MODE, // empty
- BPROTO_ACK_DISABLE_BACKUP_MODE, // empty
- BPROTO_RES_GROUPS // [[name, series], ...]
+ BPROTO_AUTH_SUCCESS=192, /* empty */
+ BPROTO_ACK_FLAGS, /* empty */
+ BPROTO_ACK_LOG_LEVEL, /* empty */
+ BPROTO_ACK_INSERT, /* empty */
+ BPROTO_ACK_REPL_FINISHED, /* empty */
+ BPROTO_ACK_REGISTER_SERVER, /* empty */
+ BPROTO_ACK_DROP_SERIES, /* empty */
+ BPROTO_ACK_ENABLE_BACKUP_MODE, /* empty */
+ BPROTO_ACK_DISABLE_BACKUP_MODE, /* empty */
+ BPROTO_RES_GROUPS /* [[name, series], ...] */
} bproto_server_t;
#include <siri/net/pkg.h>
#define ADDR_BUF_SZ 54
-#define RESET_BUF_SIZE 1048576 // 1 MB
+#define RESET_BUF_SIZE 1048576 /* 1 MB */
/* Warning: do not change the order! (maps to dns_req_family_map) */
enum
QUERY_DEF
query_alter_tp alter_tp;
union query_alter_u via;
- size_t n; // can be used as counter
+ size_t n; /* can be used as counter */
} query_alter_t;
typedef struct query_count_s
{
QUERY_DEF
- size_t n; // can be used as counter
+ size_t n; /* can be used as counter */
} query_count_t;
typedef struct query_drop_s
{
QUERY_DEF
- size_t n; // keep a counter for number of drops.
+ size_t n; /* keep a counter for number of drops. */
slist_t * shards_list;
} query_drop_t;
typedef struct query_list_s
{
QUERY_DEF
- slist_t * props; // will be freed
+ slist_t * props; /* will be freed */
size_t limit;
} query_list_t;
QUERY_DEF
size_t n;
size_t nselects;
- uint64_t * start_ts; // will NOT be freed
- uint64_t * end_ts; // will NOT be freed
+ uint64_t * start_ts; /* will NOT be freed */
+ uint64_t * end_ts; /* will NOT be freed */
siridb_presuf_t * presuf;
char * merge_as;
ct_t * result;
- imap_t * points_map; // points_map for caching
- slist_t * alist; // aggregation list (can be used multiple times)
- slist_t * mlist; // merge aggregation list
+ imap_t * points_map; /* points_map for caching */
+ slist_t * alist; /* aggregation list (can be used multiple times)*/
+ slist_t * mlist; /* merge aggregation list */
} query_select_t;
query_alter_t * query_alter_new(void);
#include <stdlib.h>
#include <strextra/strextra.h>
#include <string.h>
-
-// #define NDEBUG
#include <assert.h>
#define HELP_WIDTH 80 /* try to fit help within this screen width */
{
if (ct->nodes != NULL)
{
- for (uint_fast16_t i = 0, end = ct->n * BLOCKSZ; i < end; i++)
+ uint_fast16_t i, end;
+ for (i = 0, end = ct->n * BLOCKSZ; i < end; i++)
{
if ((*ct->nodes)[i] != NULL)
{
ct_node_t * nd;
int rc = 0;
char * buffer = (char *) malloc(buffer_sz);
+ uint_fast16_t i, end;
+
if (buffer == NULL)
{
return -1;
}
- for (uint_fast16_t i = 0, end = ct->n * BLOCKSZ; !rc && i < end; i++)
+ for (i = 0, end = ct->n * BLOCKSZ; !rc && i < end; i++)
{
if ((nd = (*ct->nodes)[i]) == NULL)
{
{
ct_node_t * nd;
int rc = 0;
+ uint_fast16_t i, end;
- for (uint_fast16_t i = 0, end = ct->n * BLOCKSZ; i < end; i++)
+ for (i = 0, end = ct->n * BLOCKSZ; i < end; i++)
{
if ((nd = (*ct->nodes)[i]) == NULL)
{
void ct_valuesn(ct_t * ct, size_t * n, ct_val_cb cb, void * args)
{
ct_node_t * nd;
+ uint_fast16_t i, end;
- for (uint_fast16_t i = 0, end = ct->n * BLOCKSZ; *n && i < end; i++)
+ for (i = 0, end = ct->n * BLOCKSZ; *n && i < end; i++)
{
if ((nd = (*ct->nodes)[i]) == NULL)
{
{
ct_node_t * nd;
int rc;
+ uint_fast16_t i, end;
- for (uint_fast16_t i = 0, end = node->n * BLOCKSZ; i < end; i++)
+ for (i = 0, end = node->n * BLOCKSZ; i < end; i++)
{
if ((nd = (*node->nodes)[i]) == NULL)
{
if (node->nodes != NULL)
{
ct_node_t * nd;
+ uint_fast16_t i, end;
- for (uint_fast16_t i = 0, end = node->n * BLOCKSZ; i < end; i++)
+ for (i = 0, end = node->n * BLOCKSZ; i < end; i++)
{
if ((nd = (*node->nodes)[i]) == NULL)
{
if (node->nodes != NULL)
{
ct_node_t * nd;
+ uint_fast16_t i, end;
- for (uint_fast16_t i = 0, end = node->n * BLOCKSZ; *n && i < end; i++)
+ for (i = 0, end = node->n * BLOCKSZ; *n && i < end; i++)
{
if ((nd = (*node->nodes)[i]) == NULL)
{
const char * key,
void * data)
{
- for (size_t n = 0; n < node->len; n++, key++)
+ size_t n;
+ for (n = 0; n < node->len; n++, key++)
{
char * pt = node->key + n;
if (*key != *pt)
{
size_t new_sz;
uint8_t k = (uint8_t) *pt;
+ ct_node_t * nd;
/* create new nodes */
ct_nodes_t * new_nodes =
}
/* create new nodes with rest of node pt */
- ct_node_t * nd = (*new_nodes)[k % BLOCKSZ] =
+ nd = (*new_nodes)[k % BLOCKSZ] =
CT_node_new(pt + 1, node->len - n - 1, node->data);
if (nd == NULL)
{
ct_nodes_t * tmp;
uint8_t diff = pos - node->offset - node->n + 1;
uint8_t oldn = node->n;
- node->n += diff; // assert node->n > 0
+ node->n += diff; /* assert node->n > 0 */
tmp = (ct_nodes_t *) realloc(
node->nodes,
node->n * sizeof(ct_nodes_t));
{
if (node->nodes != NULL)
{
- for (uint_fast16_t i = 0, end = node->n * BLOCKSZ; i < end; i++)
+ uint_fast16_t i, end;
+ for (i = 0, end = node->n * BLOCKSZ; i < end; i++)
{
if ((*node->nodes)[i] != NULL)
{
}
else if (**expression == '(')
{
- (*expression)++; // '('
+ (*expression)++; /* '(' */
int64_t result = expr_expression(expression);
- (*expression)++; // ')'
+ (*expression)++; /* ')' */
return result;
}
else if (**expression == '-')
(*expression)++;
return -expr_factor(expression);
}
- return 0; // error
+ return 0; /* error */
}
static int64_t expr_term(const char ** expression)
{
int64_t result = expr_factor(expression);
int64_t temp;
+ int i;
- for (int i = 1; i;)
+ for (i = 1; i;)
switch (*(*expression))
{
case '*':
if (imap->len)
{
imap_node_t * nd;
+ uint_fast8_t i;
if (cb == NULL)
{
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = imap->nodes + i;
}
else
{
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = imap->nodes + i;
if (imap->len)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = imap->nodes + i;
if (imap->len)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; *n && i < IMAP_NODE_SZ; i++)
+ for (i = 0; *n && i < IMAP_NODE_SZ; i++)
{
nd = imap->nodes + i;
if (imap->slist != NULL && imap->len)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = imap->nodes + i;
if (imap->slist != NULL && imap->len)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = imap->nodes + i;
}
else
{
- for (size_t i = 0; i < imap->slist->len; i++)
+ size_t i;
+ for (i = 0; i < imap->slist->len; i++)
{
slist_object_incref(imap->slist->data[i]);
}
{
imap_node_t * dest_nd;
imap_node_t * imap_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
imap_nd = imap->nodes + i;
imap_node_t * dest_nd;
imap_node_t * imap_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
imap_nd = imap->nodes + i;
{
imap_node_t * dest_nd;
imap_node_t * imap_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
imap_nd = imap->nodes + i;
{
imap_node_t * dest_nd;
imap_node_t * imap_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
imap_nd = imap->nodes + i;
static void IMAP_node_free(imap_node_t * node)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
if ((nd = node->nodes + i)->nodes != NULL)
{
static void IMAP_node_free_cb(imap_node_t * node, imap_free_cb cb)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = node->nodes + i;
static void IMAP_walk(imap_node_t * node, imap_cb cb, void * data, int * rc)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = node->nodes + i;
static void IMAP_walkn(imap_node_t * node, imap_cb cb, void * data, size_t * n)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; *n && i < IMAP_NODE_SZ; i++)
+ for (i = 0; *n && i < IMAP_NODE_SZ; i++)
{
nd = node->nodes + i;
static void IMAP_2slist(imap_node_t * node, slist_t * slist)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = node->nodes + i;
static void IMAP_2slist_ref(imap_node_t * node, slist_t * slist)
{
imap_node_t * nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
nd = node->nodes + i;
{
imap_node_t * dest_nd;
imap_node_t * node_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
node_nd = node->nodes + i;
{
imap_node_t * dest_nd;
imap_node_t * node_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
node_nd = node->nodes + i;
{
imap_node_t * dest_nd;
imap_node_t * node_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
node_nd = node->nodes + i;
{
imap_node_t * dest_nd;
imap_node_t * node_nd;
+ uint_fast8_t i;
- for (uint_fast8_t i = 0; i < IMAP_NODE_SZ; i++)
+ for (i = 0; i < IMAP_NODE_SZ; i++)
{
dest_nd = dest->nodes + i;
node_nd = node->nodes + i;
#define LOGGER_CHR_MAP "DIWECU"
-#define KNRM "\x1B[0m" // normal
-#define KRED "\x1B[31m" // error
-#define KGRN "\x1B[32m" // info
-#define KYEL "\x1B[33m" // warning
-#define KBLU "\x1B[34m" // -- not used --
-#define KMAG "\x1B[35m" // critical
-#define KCYN "\x1B[36m" // debug
-#define KWHT "\x1B[37m" // -- not used --
+#define KNRM "\x1B[0m" /* normal */
+#define KRED "\x1B[31m" /* error */
+#define KGRN "\x1B[32m" /* info */
+#define KYEL "\x1B[33m" /* warning */
+#define KBLU "\x1B[34m" /* -- not used -- */
+#define KMAG "\x1B[35m" /* critical */
+#define KCYN "\x1B[36m" /* debug */
+#define KWHT "\x1B[37m" /* -- not used -- */
const char * LOGGER_LEVEL_NAMES[LOGGER_NUM_LEVELS] =
{"debug", "info", "warning", "error", "critical"};
* char[OWCRYPT_SZ] encrypted;
* owcrypt("my_password", "saltsalt$1", encrypted);
*
- * // Checking can be done like this:
+ * # Checking can be done like this:
* char[OWCRYPT_SZ] pw;
* owcrypt("pasword_to_check", encrypted, pw");
* if (strcmp(pw, encrypted) === 0) {
- * // valid
+ * # valid
* }
*
* Parameters:
#include <siri/db/server.h>
#include <siri/version.h>
-// 15 seconds
+/* 15 seconds */
#define CLIENT_REQUEST_TIMEOUT 15000
#define CLIENT_FLAGS_TIMEOUT 1
#define CLIENT_FLAGS_NO_ROLLBACK 2
qp_obj_t qp_uuid;
siridb_t * siridb;
int rc;
- char fn[strlen(adm_client->dbpath) + 13]; // 13 = strlen("database.dat")+1
+ /* 13 = strlen("database.dat")+1 */
+ char fn[strlen(adm_client->dbpath) + 13];
sprintf(fn, "%sdatabase.dat", adm_client->dbpath);
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
qp_unpacker_t unpacker;
qp_types_t tp;
int rc, n, close_num;
- char fn[strlen(adm_client->dbpath) + 12]; // 12 = strlen("servers.dat") + 1
+ /* 12 = strlen("servers.dat") + 1 */
+ char fn[strlen(adm_client->dbpath) + 12];
sprintf(fn, "%sservers.dat", adm_client->dbpath);
fp = fopen(fn, "w");
sirinet_pkg_t * pkg)
{
FILE * fp;
- char fn[strlen(adm_client->dbpath) + 11]; // 11 = strlen("groups.dat") + 1
+ /* 11 = strlen("groups.dat") + 1 */
+ char fn[strlen(adm_client->dbpath) + 11];
sprintf(fn, "%sgroups.dat", adm_client->dbpath);
fp = fopen(fn, "w");
sirinet_pkg_t * pkg)
{
FILE * fp;
- char fn[strlen(adm_client->dbpath) + 10]; // 10 = strlen("users.dat") + 1
+ /* 10 = strlen("users.dat") + 1 */
+ char fn[strlen(adm_client->dbpath) + 10];
sprintf(fn, "%susers.dat", adm_client->dbpath);
fp = fopen(fn, "w");
if (siri_admin_client_request(
pid,
port,
- (req == ADMIN_NEW_POOL) ? -1 : qp_pool.via.int64, // -1 = new pool
+ /* -1 = new pool */
+ (req == ADMIN_NEW_POOL) ? -1 : qp_pool.via.int64,
&uuid,
&qp_host,
&qp_username,
if (SIRI_OPTIMZE_IS_PAUSED)
{
+ size_t i;
siridb_shard_t * shard;
/*
"Cannot create shard list so not all shard files "
"will be closed in backup mode.");
}
- else for (size_t i = 0; i < shard_list->len; i++)
+ else for (i = 0; i < shard_list->len; i++)
{
shard = (siridb_shard_t *) shard_list->data[i];
*/
uint32_t siridb_access_from_strn(const char * str, size_t n)
{
- for (int i = 0; i < ACCESS_SIZE; i++)
+ int i;
+ for (i = 0; i < ACCESS_SIZE; i++)
{
if (strncmp(access_map[i].repr, str, n) == 0)
{
void siridb_access_to_str(char * str, uint32_t access_bit)
{
char * pt = str;
+ int i;
- for (int i = 0; i < ACCESS_SIZE && access_bit; i++)
+ for (i = 0; i < ACCESS_SIZE && access_bit; i++)
{
if ((access_bit & access_map[i].access_bit) == access_map[i].access_bit)
{
*/
void siridb_init_aggregates(void)
{
- for (uint_fast16_t i = 0; i < F_OFFSET; i++)
+ uint_fast16_t i;
+ for (i = 0; i < F_OFFSET; i++)
{
AGGREGATES[i] = NULL;
}
*/
void siridb_aggregate_list_free(slist_t * alist)
{
- for (size_t i = 0; i < alist->len; i++)
+ size_t i;
+ for (i = 0; i < alist->len; i++)
{
AGGREGATE_free(alist->data[i]);
}
aggr->regex,
(PCRE2_SPTR8) val,
strlen(val),
- 0, // start looking at this point
- 0, // OPTIONS
+ 0, /* start looking at this point */
+ 0, /* OPTIONS */
aggr->match_data,
- 0); // length of sub_str_vec
+ 0); /* length of sub_str_vec */
return aggr->filter_opr == CEXPR_EQ ? ret >= 0 : ret < 0;
}
i < source->len;
i++, spt++)
{
- if (value.str != NULL // NULL is a regular expression
+ if (value.str != NULL /* NULL is a regular expression */
? cexpr_str_cmp(
aggr->filter_opr,
spt->val.str, value.str)
if (points->tp == TP_INT)
{
int64_t max = points->data->val.int64;
- for (size_t i = 1; i < points->len; i++)
+ size_t i;
+ for (i = 1; i < points->len; i++)
{
if ((points->data + i)->val.int64 > max)
{
else
{
double max = points->data->val.real;
- for (size_t i = 1; i < points->len; i++)
+ size_t i;
+ for (i = 1; i < points->len; i++)
{
if ((points->data + i)->val.real > max)
{
#endif
double sum = 0.0;
+ size_t i;
switch (points->tp)
{
return -1;
case TP_INT:
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
sum += (points->data + i)->val.int64;
}
break;
case TP_DOUBLE:
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
sum += (points->data + i)->val.real;
}
if (points->tp == TP_INT)
{
int64_t min = points->data->val.int64;
- for (size_t i = 1; i < points->len; i++)
+ size_t i;
+ for (i = 1; i < points->len; i++)
{
if ((points->data + i)->val.int64 < min)
{
else
{
double min = points->data->val.real;
- for (size_t i = 1; i < points->len; i++)
+ size_t i;
+ for (i = 1; i < points->len; i++)
{
if ((points->data + i)->val.real < min)
{
{
int64_t sum = 0;
int64_t tmp;
- for (size_t i = 0; i < points->len; i++)
+ size_t i;
+ for (i = 0; i < points->len; i++)
{
tmp = (points->data + i)->val.int64;
if ((tmp > 0 && sum > LLONG_MAX - tmp) ||
case TP_DOUBLE:
{
double sum = 0.0;
- for (size_t i = 0; i < points->len; i++)
+ size_t i;
+ for (i = 0; i < points->len; i++)
{
sum += (points->data + i)->val.real;
}
siridb_t * siridb;
char err_msg[512];
int rc;
+ size_t i;
if (!len || dbpath[len - 1] != '/')
{
return NULL;
}
- for (size_t i = 0; i < slist->len; i++)
+ for (i = 0; i < slist->len; i++)
{
siridb_series_update_props(siridb, (siridb_series_t * )slist->data[i]);
}
#include <string.h>
#include <unistd.h>
-#define FFILE_DEFAULT_SIZE 104857600 // 100 MB
-#define FFILE_NUMBERS 9 // how much numbers are used to generate the file.
+#define FFILE_DEFAULT_SIZE 104857600 /* 100 MB */
+#define FFILE_NUMBERS 9 /* how much numbers are used to generate the file. */
/*
* Open the fifo file. (set both the file pointer and file descriptor
struct dirent ** fifo_list;
char * fn;
int total = scandir(fifo->path, &fifo_list, NULL, alphasort);
+ int n;
if (total < 0)
{
ERR_C
}
- for (int n = 0; n < total; n++)
+ for (n = 0; n < total; n++)
{
if (siridb_ffile_check_fn(fifo_list[n]->d_name))
{
}
else
{
+ uint32_t psize;
+ size_t n;
+
forward->free_cb = FORWARD_free;
forward->ref = 1; /* used as reference on (siri_async_t) handle */
forward->siridb = siridb;
* Allocate packers for sending data to pools. we allocate smaller
* sizes in case we have a lot of pools.
*/
- uint32_t psize = QP_SUGGESTED_SIZE / ((size / 4) + 1);
+ psize = QP_SUGGESTED_SIZE / ((size / 4) + 1);
- for (size_t n = 0; n < size; n++)
+ for (n = 0; n < size; n++)
{
if (n == siridb->server->pool)
{
*/
void siridb_forward_free(siridb_forward_t * forward)
{
+ size_t n;
+
/* free packer */
- for (size_t n = 0; n < forward->size; n++)
+ for (n = 0; n < forward->size; n++)
{
if (forward->packer[n] != NULL)
{
(sirinet_promises_cb) FORWARD_on_response,
handle,
NULL);
+ int pool_count = 0;
+ uint16_t n;
if (promises == NULL)
{
return; /* signal is raised */
}
- int pool_count = 0;
-
- for (uint16_t n = 0; n < forward->size; n++)
+ for (n = 0; n < forward->size; n++)
{
if ( forward->packer[n] == NULL ||
forward->packer[n]->len == sizeof(sirinet_pkg_t) + 1)
sirinet_pkg_t * pkg;
sirinet_promise_t * promise;
siridb_forward_t * forward = (siridb_forward_t *) handle->data;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
if (promise == NULL)
{
size_t dropped = 0;
siridb_series_t * series;
+ size_t i;
- for (size_t i = 0; i < group->series->len; i++)
+ for (i = 0; i < group->series->len; i++)
{
series = (siridb_series_t *) group->series->data[i];
group->regex,
(PCRE2_SPTR8) series->name,
series->name_len,
- 0, // start looking at this point
- 0, // OPTIONS
+ 0, /* start looking at this point */
+ 0, /* OPTIONS */
group->match_data,
- NULL); // length of sub_str_vec
+ NULL); /* length of sub_str_vec */
if (rc >= 0)
{
pcre2_code * new_regex;
pcre2_match_data * new_regex_match_data;
siridb_series_t * series;
+ size_t i;
if (new_source == NULL)
{
group->regex = new_regex;
group->match_data = new_regex_match_data;
- for (size_t i = 0; i < group->series->len; i++)
+ for (i = 0; i < group->series->len; i++)
{
series = (siridb_series_t *) group->series->data[i];
siridb_series_decref(series);
*/
void siridb__group_free(siridb_group_t * group)
{
+ size_t i;
+
#if DEBUG
log_debug("Free group: '%s'", group->name);
#endif
if (group->series != NULL)
{
siridb_series_t * series;
- for (size_t i = 0; i < group->series->len; i++)
+ for (i = 0; i < group->series->len; i++)
{
series = (siridb_series_t *) group->series->data[i];
siridb_series_decref(series);
#define SIRIDB_GROUPS_SCHEMA 1
#define SIRIDB_GROUPS_FN "groups.dat"
-#define GROUPS_LOOP_SLEEP 2 // 2 seconds
-#define GROUPS_LOOP_DEEP 15 // x times -> 30 seconds (used when re-indexing)
+#define GROUPS_LOOP_SLEEP 2 /* 2 seconds */
+#define GROUPS_LOOP_DEEP 15 /* x times -> 30 seconds. used when re-indexing */
#define GROUPS_RE_BATCH_SZ 1000
#define CALC_BATCH_SIZE(sz) GROUPS_RE_BATCH_SZ /((sz / 5 ) + 1) + 1;
}
else
{
- groups->ref = 2; // for the main thread and for the groups thread
+ groups->ref = 2; /* for the main thread and for the groups thread */
groups->fn = NULL;
groups->groups = ct_new();
groups->nseries = slist_new(SLIST_DEFAULT_SIZE);
static void GROUPS_free(siridb_groups_t * groups)
{
+ size_t i;
+
#if DEBUG
log_debug("Free groups");
#endif
if (groups->nseries != NULL)
{
siridb_series_t * series;
- for (size_t i = 0; i < groups->nseries->len; i++)
+ for (i = 0; i < groups->nseries->len; i++)
{
series = (siridb_series_t *) groups->nseries->data[i];
siridb_series_decref(series);
if (groups->ngroups != NULL)
{
siridb_group_t * group;
- for (size_t i = 0; i < groups->ngroups->len; i++)
+ for (i = 0; i < groups->ngroups->len; i++)
{
group = (siridb_group_t *) groups->ngroups->data[i];
siridb_group_decref(group);
{
uv_mutex_unlock(&groups->mutex);
- usleep(10000); // 10ms
+ usleep(10000); /* 10ms */
uv_mutex_lock(&groups->mutex);
*/
static void GROUPS_init_groups(siridb_t * siridb)
{
+ siridb_groups_t * groups = siridb->groups;
+ siridb_group_t * group;
+ slist_t * series_list;
+ siridb_series_t * series;
+ size_t i;
+
#if DEBUG
/* do not run this function when no groups need initialization */
assert (siridb->groups->ngroups->len);
#endif
- siridb_groups_t * groups = siridb->groups;
- siridb_group_t * group;
-
- slist_t * series_list;
- siridb_series_t * series;
uv_mutex_lock(&siridb->series_mutex);
series_list = (groups->nseries->len) ?
/* remove INIT flag from group */
group->flags &= ~GROUP_FLAG_INIT;
- for (size_t i = 0; i < series_list->len; i++)
+ for (i = 0; i < series_list->len; i++)
{
series = (siridb_series_t *) series_list->data[i];
{
uv_mutex_unlock(&groups->mutex);
- usleep(10000); // 10ms
+ usleep(10000); /* 10ms */
uv_mutex_lock(&groups->mutex);
}
uv_mutex_unlock(&groups->mutex);
- usleep(10000); // 10ms
+ usleep(10000); /* 10ms */
uv_mutex_lock(&groups->mutex);
}
uv_mutex_unlock(&groups->mutex);
- for (size_t i = 0; i < series_list->len; i++)
+ for (i = 0; i < series_list->len; i++)
{
series = (siridb_series_t *) series_list->data[i];
siridb_series_decref(series);
siridb_group_decref(group);
- usleep(10000); // 10ms
+ usleep(10000); /* 10ms */
}
slist_free(groups_list);
#include <siri/optimize.h>
#include <qpack/qpack.h>
-#define INITSYNC_SLEEP 100 // 100 milliseconds * active tasks
-#define INITSYNC_TIMEOUT 120000 // 2 minutes
-#define INITSYNC_RETRY 30000 // 30 seconds
+#define INITSYNC_SLEEP 100 /* 100 milliseconds * active tasks */
+#define INITSYNC_TIMEOUT 120000 /* 2 minutes */
+#define INITSYNC_RETRY 30000 /* 30 seconds */
#define INITSYC_FN ".initsync"
void siridb_initsync_fopen(siridb_initsync_t * initsync, const char * opentype);
#include <siri/db/tasks.h>
#define MAX_INSERT_MSG 236
-#define INSERT_TIMEOUT 300000 // 5 minutes
-#define INSERT_AT_ONCE 3000 // one point counts as 1, a series as 100
+#define INSERT_TIMEOUT 300000 /* 5 minutes */
+#define INSERT_AT_ONCE 3000 /* one point counts as 1, a series as 100 */
#define WEIGHT_SERIES 50
#define WEIGHT_NEW_SERIES 100
*/
void siridb_insert_free(siridb_insert_t * insert)
{
+ size_t n;
+
/* free packer */
- for (size_t n = 0; n < insert->packer_size; n++)
+ for (n = 0; n < insert->packer_size; n++)
{
if (insert->packer[n] != NULL)
{
}
else
{
+ size_t n;
+ uint32_t psize;
+
insert->free_cb = INSERT_free;
insert->ref = 1; /* used as reference on (siri_async_t) handle */
* Allocate packers for sending data to pools. we allocate smaller
* sizes in case we have a lot of pools.
*/
- uint32_t psize = QP_SUGGESTED_SIZE / ((siridb->pools->len / 4) + 1);
+ psize = QP_SUGGESTED_SIZE / ((siridb->pools->len / 4) + 1);
- for (size_t n = 0; n < siridb->pools->len; n++)
+ for (n = 0; n < siridb->pools->len; n++)
{
if ((insert->packer[n] = sirinet_packer_new(psize)) == NULL)
{
handle->data = ilocal;
- qp_next(&ilocal->unpacker, NULL); // map
- qp_next(&ilocal->unpacker, &ilocal->qp_series_name); // first series or end
+ qp_next(&ilocal->unpacker, NULL); /* map */
+ qp_next(&ilocal->unpacker, &ilocal->qp_series_name); /* first series/end */
siridb_tasks_inc(siridb->tasks);
siridb->insert_tasks++;
if (packer != NULL)
{
cproto_server_t tp = CPROTO_RES_INSERT;
+ size_t i;
+ sirinet_pkg_t * response_pkg;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
if (siri_err || promise == NULL)
(const unsigned char *) msg,
(n < MAX_INSERT_MSG) ? n : MAX_INSERT_MSG);
- sirinet_pkg_t * response_pkg = sirinet_packer2pkg(
+ response_pkg = sirinet_packer2pkg(
packer,
insert->pid,
tp);
siridb->series,
(const char *) qp_series_name->via.raw);
- qp_next(unpacker, NULL); // array open
- qp_next(unpacker, NULL); // first point array2
- qp_next(unpacker, &qp_series_ts); // first ts
- qp_next(unpacker, &qp_series_val); // first val
+ qp_next(unpacker, NULL); /* array open */
+ qp_next(unpacker, NULL); /* first point array2 */
+ qp_next(unpacker, &qp_series_ts); /* first ts */
+ qp_next(unpacker, &qp_series_val); /* first val */
if (series == NULL)
{
if (tp == QP_ARRAY2) do
{
- qp_next(unpacker, &qp_series_ts); // ts
- qp_next(unpacker, &qp_series_val); // val
+ qp_next(unpacker, &qp_series_ts); /* ts */
+ qp_next(unpacker, &qp_series_val); /* val */
if (series->tp == TP_STRING)
{
/* save pointer position and read series type */
pt = unpacker->pt;
- qp_next(unpacker, NULL); // array open
- qp_next(unpacker, NULL); // first point array2
- qp_next(unpacker, NULL); // first ts
- qp_next(unpacker, &qp_series_val); // first val
+ qp_next(unpacker, NULL); /* array open */
+ qp_next(unpacker, NULL); /* first point array2 */
+ qp_next(unpacker, NULL); /* first ts */
+ qp_next(unpacker, &qp_series_val); /* first val */
/* restore pointer position */
unpacker->pt = pt;
* Skip this series since it will forwarded to the correct
* pool by the replica server.
*/
- qp_skip_next(unpacker); // array
+ qp_skip_next(unpacker); /* array */
qp_next(unpacker, qp_series_name);
continue; /* expected to be 0 */
}
}
- qp_next(unpacker, NULL); // array open
- qp_next(unpacker, NULL); // first point array2
- qp_next(unpacker, &qp_series_ts); // first ts
- qp_next(unpacker, &qp_series_val); // first val
+ qp_next(unpacker, NULL); /* array open */
+ qp_next(unpacker, NULL); /* first point array2 */
+ qp_next(unpacker, &qp_series_ts); /* first ts */
+ qp_next(unpacker, &qp_series_val); /* first val */
ts = (uint64_t *) &qp_series_ts.via.int64;
SERIES_UPDATE_TS(series)
if (tp == QP_ARRAY2) do
{
- qp_next(unpacker, &qp_series_ts); // ts
- qp_next(unpacker, &qp_series_val); // val
+ qp_next(unpacker, &qp_series_ts); /* ts */
+ qp_next(unpacker, &qp_series_val); /* val */
if (series->tp == TP_STRING)
{
handle->data = ilocal;
- qp_next(&ilocal->unpacker, NULL); // map
- qp_next(&ilocal->unpacker, &ilocal->qp_series_name); // first series or end
+ qp_next(&ilocal->unpacker, NULL); /* map */
+ qp_next(&ilocal->unpacker, &ilocal->qp_series_name); /* first series/end */
siridb_tasks_inc(siridb->tasks);
siridb->insert_tasks++;
(sirinet_promises_cb) INSERT_on_response,
handle,
NULL);
+ int pool_count = 0;
+ uint16_t n;
if (promises == NULL)
{
return; /* signal is raised */
}
- int pool_count = 0;
-
- for (uint16_t n = 0; n < insert->packer_size; n++)
+ for (n = 0; n < insert->packer_size; n++)
{
if (insert->packer[n]->len == sizeof(sirinet_pkg_t) + 1)
{
}
if (points->tp == TP_STRING)
{
- for (size_t i = 0; i < points->len; ++i)
+ size_t i;
+ for (i = 0; i < points->len; ++i)
{
(cpoints->data + i)->val.str =
strdup((points->data + i)->val.str);
{
if (points->tp == TP_STRING)
{
- for (size_t i = 0; i < points->len; ++i)
+ size_t i;
+ for (i = 0; i < points->len; ++i)
{
free((points->data + i)->val.str);
}
qp_add_type(packer, QP_ARRAY_OPEN);
if (points->len)
{
+ size_t i;
siridb_point_t * point = points->data;
switch (points->tp)
{
case TP_INT:
- for (size_t i = 0; i < points->len; i++, point++)
+ for (i = 0; i < points->len; i++, point++)
{
qp_add_type(packer, QP_ARRAY2);
qp_add_int64(packer, (int64_t) point->ts);
}
break;
case TP_DOUBLE:
- for (size_t i = 0; i < points->len; i++, point++)
+ for (i = 0; i < points->len; i++, point++)
{
qp_add_type(packer, QP_ARRAY2);
qp_add_int64(packer, (int64_t) point->ts);
}
break;
case TP_STRING:
- for (size_t i = 0; i < points->len; i++, point++)
+ for (i = 0; i < points->len; i++, point++)
{
qp_add_type(packer, QP_ARRAY2);
qp_add_int64(packer, (int64_t) point->ts);
void siridb_points_ts_correction(siridb_points_t * points, double factor)
{
siridb_point_t * point = points->data;
- for (size_t i = 0; i < points->len; i++, point++)
+ size_t i;
+ for (i = 0; i < points->len; i++, point++)
{
point->ts *= factor;
}
uint_fast32_t n = end - start;
size_t * sizes = (size_t *) malloc(sizeof(size_t) * n);
+ size_t * psz = sizes;
+ unsigned char * pdata;
+ unsigned char * cdata;
+ uint_fast32_t i;
+
if (sizes == NULL)
{
return NULL;
}
- size_t * psz = sizes;
- unsigned char * pdata;
-
- for (uint_fast32_t i = start; i < end; ++i, ++psz)
+ for (i = start; i < end; ++i, ++psz)
{
*psz = strlen(points->data[i].val.str) + 1;
*size += *psz;
/* when uncompressed, time-stamp size is not included */
*size += n * ts_sz;
- unsigned char * cdata = (unsigned char *) calloc(
- *size, sizeof(unsigned char));
+ cdata = (unsigned char *) calloc(*size, sizeof(unsigned char));
if (cdata == NULL)
{
free(sizes);
switch (ts_sz)
{
case sizeof(uint32_t):
- for (uint_fast32_t i = start; i < end; ++i)
+ for (i = start; i < end; ++i)
{
uint32_t ts = points->data[i].ts;
memcpy(pdata, &ts, sizeof(uint32_t));
}
break;
case sizeof(uint64_t):
- for (uint_fast32_t i = start; i < end; ++i)
+ for (i = start; i < end; ++i)
{
memcpy(pdata, &points->data[i].ts, sizeof(uint64_t));
pdata += sizeof(uint64_t);
assert(0);
}
- for (uint_fast32_t i = start; i < end; ++i, ++psz)
+ for (i = start; i < end; ++i, ++psz)
{
memcpy(pdata, points->data[i].val.str, *psz);
pdata += *psz;
size_t * size)
{
uint_fast32_t n = end - start;
+ uint_fast32_t i;
+ unsigned char * bits;
+ unsigned char * pt;
+
*size = n * 16;
*cinfo = 0xffff;
- unsigned char * bits = (unsigned char *) malloc(*size);
+
+ bits = (unsigned char *) malloc(*size);
if (bits == NULL)
{
return NULL;
}
- unsigned char * pt = bits;
- for (uint_fast32_t i = start; i < end; ++i)
+
+ pt = bits;
+ for (i = start; i < end; ++i)
{
memcpy(pt, &points->data[i].ts, sizeof(uint64_t));
pt += sizeof(uint64_t);
memcpy(pt, &points->data[i].val, sizeof(uint64_t));
pt += sizeof(uint64_t);
}
+
return bits;
}
*/
int siridb_pool_online(siridb_pool_t * pool)
{
- for (uint16_t i = 0; i < pool->len; i++)
+ uint16_t i;
+ for (i = 0; i < pool->len; i++)
{
if (siridb_server_is_online(pool->server[i]))
{
- return 1; // true
+ return 1; /* true */
}
}
- return 0; // false
+ return 0; /* false */
}
/*
*/
int siridb_pool_available(siridb_pool_t * pool)
{
- for (uint16_t i = 0; i < pool->len; i++)
+ uint16_t i;
+ for (i = 0; i < pool->len; i++)
{
if (siridb_server_is_available(pool->server[i]))
{
- return 1; // true
+ return 1; /* true */
}
}
- return 0; // false
+ return 0; /* false */
}
/*
*/
int siridb_pool_accessible(siridb_pool_t * pool)
{
- for (uint16_t i = 0; i < pool->len; i++)
+ uint16_t i;
+ for (i = 0; i < pool->len; i++)
{
if (siridb_server_is_accessible(pool->server[i]))
{
- return 1; // true
+ return 1; /* true */
}
}
- return 0; // false
+ return 0; /* false */
}
int flags)
{
siridb_server_t * server = NULL;
+ uint16_t i;
- for (uint16_t i = 0; i < pool->len; i++)
+ for (i = 0; i < pool->len; i++)
{
if ((flags & FLAG_ONLY_CHECK_ONLINE) ?
siridb_server_is_online(pool->server[i]) :
*/
int siridb_pools_online(siridb_t * siridb)
{
- for (uint16_t pid = 0; pid < siridb->pools->len; pid++)
+ uint16_t pid ;
+ for (pid = 0; pid < siridb->pools->len; pid++)
{
if ( pid != siridb->server->pool &&
!siridb_pool_online(siridb->pools->pool + pid))
{
- return 0; // false
+ return 0; /* false */
}
}
- return 1; //true
+ return 1; /* true */
}
/*
*/
int siridb_pools_available(siridb_t * siridb)
{
- for (uint16_t pid = 0; pid < siridb->pools->len; pid++)
+ uint16_t pid;
+ for (pid = 0; pid < siridb->pools->len; pid++)
{
if ( pid != siridb->server->pool &&
!siridb_pool_available(siridb->pools->pool + pid))
{
- return 0; // false
+ return 0; /* false */
}
}
- return 1; //true
+ return 1; /* true */
}
*/
int siridb_pools_accessible(siridb_t * siridb)
{
- for (uint16_t pid = 0; pid < siridb->pools->len; pid++)
+ uint16_t pid;
+ for (pid = 0; pid < siridb->pools->len; pid++)
{
if ( pid != siridb->server->pool &&
!siridb_pool_accessible(siridb->pools->pool + pid))
{
- return 0; // false
+ return 0; /* false */
}
}
- return 1; //true
+ return 1; /* true */
}
/*
else
{
siridb_pool_t * pool;
+ uint16_t pid;
- for (uint16_t pid = 0; pid < siridb->pools->len; pid++)
+ for (pid = 0; pid < siridb->pools->len; pid++)
{
if (pid == siridb->server->pool)
{
else
{
siridb_pool_t * pool;
+ size_t i;
- for (size_t i = 0; i < slist->len; i++)
+ for (i = 0; i < slist->len; i++)
{
pool = slist->data[i];
void siridb_init_props(void)
{
- for (uint_fast16_t i = 0; i < KW_COUNT; i++)
+ uint_fast16_t i;
+
+ for (i = 0; i < KW_COUNT; i++)
+ {
siridb_props[i] = NULL;
+ }
siridb_props[CLERI_GID_K_ACTIVE_HANDLES - KW_OFFSET] =
prop_active_handles;
#define QUERY_TOO_LONG -1
#define QUERY_MAX_LENGTH 8192
#define QUERY_EXTRA_ALLOC_SIZE 200
-#define SIRIDB_FWD_SERVERS_TIMEOUT 5000 // 5 seconds
+#define SIRIDB_FWD_SERVERS_TIMEOUT 5000 /* 5 seconds */
static void QUERY_send_invalid_error(uv_async_t * handle);
static void QUERY_parse(uv_async_t * handle);
sirinet_pkg_t * package = sirinet_pkg_err(
query->pid,
strlen(query->err_msg),
- err, // usually this is CPROTO_ERR_QUERY, CPROTO_ERR_POOL etc.
+ err, /* usually this is CPROTO_ERR_QUERY, CPROTO_ERR_POOL...*/
query->err_msg);
log_warning("(%s) %s", sirinet_cproto_server_str(err), query->err_msg);
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if (qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // error_msg
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* error_msg */
qp_is_raw(qp_next(&unpacker, &qp_err)) &&
qp_err.len < SIRIDB_MAX_SIZE_ERR_MSG)
{
#include <stdio.h>
#include <unistd.h>
-#define REINDEX_SLEEP 100 // 100 milliseconds * active tasks
-#define REINDEX_RETRY 5000 // 5 seconds
-#define REINDEX_INITWAIT 20000 // 20 seconds
-#define REINDEX_TIMEOUT 300000 // 5 minutes
+#define REINDEX_SLEEP 100 /* 100 milliseconds * active tasks */
+#define REINDEX_RETRY 5000 /* 5 seconds */
+#define REINDEX_INITWAIT 20000 /* 20 seconds */
+#define REINDEX_TIMEOUT 300000 /* 5 minutes */
#define NEXT_SERIES_ERR -1
#define NEXT_SERIES_SET 0
#include <siri/siri.h>
#include <stddef.h>
-#define REPLICATE_SLEEP 10 // 10 milliseconds * active tasks
-#define REPLICATE_TIMEOUT 300000 // 5 minutes
+#define REPLICATE_SLEEP 10 /* 10 milliseconds * active tasks */
+#define REPLICATE_TIMEOUT 300000 /* 5 minutes */
static void REPLICATE_work(uv_timer_t * handle);
static void REPLICATE_on_repl_response(
qp_obj_t qp_series_name;
- qp_next(&unpacker, NULL); // map
+ qp_next(&unpacker, NULL); /* map */
qp_add_type(netpacker, QP_MAP_OPEN);
- qp_next(&unpacker, &qp_series_name); // first series or end
+ qp_next(&unpacker, &qp_series_name); /* first series or end */
while (qp_is_raw_term(&qp_series_name))
{
series = (siridb_series_t *) ct_get(
else
{
siridb_point_t *__restrict point;
+ size_t i;
- for (size_t i = 0; i < pcache->len; i++)
+ for (i = 0; i < pcache->len; i++)
{
point = pcache->data + i;
*/
void siridb__series_free(siridb_series_t *__restrict series)
{
+ siridb_shard_t * shard;
+ uint_fast32_t i;
+
#if DEBUG
if (siri.status == SIRI_STATUS_RUNNING || 0)
{
}
#endif
- siridb_shard_t * shard;
-
/* mark shards with dropped series flag */
- for (uint_fast32_t i = 0; i < series->idx_len; i++)
+ for (i = 0; i < series->idx_len; i++)
{
shard = series->idx[i].shard;
shard->flags |= SIRIDB_SHARD_HAS_DROPPED_SERIES;
*/
int siridb_series_load(siridb_t * siridb)
{
+ imap_t * dropped;
+
#if DEBUG
/* we must have a server because we need to know the pool id */
assert (siridb->server != NULL);
#endif
log_info("Loading series");
- imap_t * dropped = imap_new();
+ dropped = imap_new();
if (dropped == NULL)
{
*/
static void SERIES_update_overlap(siridb_series_t *__restrict series)
{
+ uint_fast32_t i;
+
#if DEBUG
assert (series->flags & SIRIDB_SERIES_HAS_OVERLAP);
#endif
- for (uint_fast32_t i = 1; i < series->idx_len; i++)
+ for (i = 1; i < series->idx_len; i++)
{
if (series->idx[i - 1].end_ts > series->idx[i].start_ts)
{
if (!xpath_file_exist(fn))
{
- // missing series file, create an empty file and return
+ /* missing series file, create an empty file and return */
return SERIES_save(siridb);
}
{
uint64_t start = 0;
idx_t * idx;
- for (uint_fast32_t i = series->idx_len; i--;)
+ uint_fast32_t i;
+
+ for (i = series->idx_len; i--;)
{
idx = series->idx + i;
#define SIRIDB_SERVERS_FN "servers.dat"
#define SIRIDB_SERVERS_SCHEMA 1
-#define SIRIDB_SERVER_FLAGS_TIMEOUT 5000 // 5 seconds
-#define SIRIDB_SERVER_PROMISES_QUEUE_SIZE 250 // max concurrent promises
+#define SIRIDB_SERVER_FLAGS_TIMEOUT 5000 /* 5 seconds */
+#define SIRIDB_SERVER_PROMISES_QUEUE_SIZE 250 /* max concurrent promises */
#define FMT_AS_IPV6(addr) (strchr(addr, ':') != NULL)
static int SERVER_update_name(siridb_server_t * server);
/* we must initialize the buffer according to the longest possible value */
char buffer[128] = {};
int n = 0;
- for (int i = 1; i < SERVER_FLAG_AUTHENTICATED; i *= 2)
+ int i;
+
+ for (i = 1; i < SERVER_FLAG_AUTHENTICATED; i *= 2)
{
if (server->flags & i)
{
switch (server_node->cl_obj->tp)
{
- case CLERI_TP_CHOICE: // server name
+ case CLERI_TP_CHOICE: /* server name */
{
char name[server_node->len - 1];
strx_extract_string(name, server_node->str, server_node->len);
}
break;
- case CLERI_TP_REGEX: // uuid
+ case CLERI_TP_REGEX: /* uuid */
{
uuid_t uuid;
char * str_uuid = strndup(server_node->str, server_node->len);
{
siridb_server_t * server;
slist_t * servers = slist_new(siridb->servers->len - 1);
+ llist_node_t * node;
+
if (servers == NULL)
{
return NULL;
}
- for ( llist_node_t * node = siridb->servers->first;
+ for ( node = siridb->servers->first;
node != NULL;
node = node->next)
{
else
{
siridb_server_t * server;
+ size_t i;
- for (size_t i = 0; i < servers->len; i++)
+ for (i = 0; i < servers->len; i++)
{
server = (siridb_server_t *) servers->data[i];
(cexpr_cb_t) siridb_server_cexpr_cb,
&wserver))
{
- return 0; // false
+ return 0; /* false */
}
qp_add_type(query->packer, QP_ARRAY_OPEN);
qp_add_type(query->packer, QP_ARRAY_CLOSE);
- return 1; // true
+ return 1; /* true */
}
/*
{
siridb_server_t * server;
int n = 0;
- for ( llist_node_t * node = siridb->servers->first;
+ llist_node_t * node;
+
+ for ( node = siridb->servers->first;
node != NULL;
node = node->next)
{
int siridb_shard_status(char * str, siridb_shard_t * shard)
{
char * pt = str;
+ int i;
+ uint8_t flags;
if (shard->replacing != NULL)
{
pt += sprintf(pt, "optimizing");
}
- uint8_t flags = shard->flags;
+ flags = shard->flags;
- for (int i = 1; i < SHARD_STATUS_SIZE && flags; i++)
+ for (i = 1; i < SHARD_STATUS_SIZE && flags; i++)
{
if ((flags & flags_map[i].flag) == flags_map[i].flag)
{
if (fseeko(idx->shard->fp->fp, idx->pos, SEEK_SET) ||
fread(
temp,
- 12, // NUM32 point size
+ 12, /* NUM32 point size */
idx->len,
idx->shard->fp->fp) != idx->len)
{
/* crop from end if needed */
if (end_ts != NULL)
{
- for ( uint32_t * p = temp + 3 * (idx->len - 1);
+ uint32_t * p;
+ for ( p = temp + 3 * (idx->len - 1);
*p >= *end_ts;
p -= 3, len--);
}
points->len &&
(idx->shard->flags & SIRIDB_SHARD_HAS_OVERLAP))
{
- for (uint64_t ts; points->len < len; pt += 3)
+ uint64_t ts;
+ for (; points->len < len; pt += 3)
{
ts = (uint64_t) *pt;
siridb_points_add_point(points, &ts, ((qp_via_t *) (pt + 1)));
if (fseeko(idx->shard->fp->fp, idx->pos, SEEK_SET) ||
fread(
temp,
- 16, // NUM64 point size
+ 16, /* NUM64 point size */
idx->len,
idx->shard->fp->fp) != idx->len)
{
/* crop from end if needed */
if (end_ts != NULL)
{
- for ( uint64_t * p = temp + 2 * (idx->len - 1);
+ uint64_t * p;
+ for ( p = temp + 2 * (idx->len - 1);
*p >= *end_ts;
p -= 2, len--);
}
/* crop from end if needed */
if (end_ts != NULL)
{
- for (uint32_t * p = tdata + (idx->len - 1); *p >= *end_ts; --p, len--);
+ uint32_t * p;
+ for (p = tdata + (idx->len - 1); *p >= *end_ts; --p, len--);
}
if ( has_overlap &&
/* crop from end if needed */
if (end_ts != NULL)
{
- for (uint64_t * p = tdata + (idx->len - 1); *p >= *end_ts; --p, len--);
+ uint64_t * p;
+ for (p = tdata + (idx->len - 1); *p >= *end_ts; --p, len--);
}
if ( has_overlap &&
uint64_t duration = (shard->tp == SIRIDB_SHARD_TP_NUMBER) ?
siridb->duration_num : siridb->duration_log;
siridb_series_t * series;
+ size_t i;
uv_mutex_lock(&siridb->shards_mutex);
sleep(1);
- for (size_t i = 0; i < slist->len; i++)
+ for (i = 0; i < slist->len; i++)
{
/* its possible that another database is paused, but we wait anyway */
if (siri.optimize->pause)
if (optimizing)
{
slist_t * slist = imap_2slist_ref(siridb->series_map);
+ size_t i;
if (slist == NULL)
{
ERR_ALLOC
}
- else for (size_t i = 0; i < slist->len; i++)
+ else for (i = 0; i < slist->len; i++)
{
series = (siridb_series_t *) slist->data[i];
if (shard->id % siridb->duration_num == series->mask)
else
{
slist_t * slist = imap_2slist(siridb->series_map);
+ size_t i;
if (slist == NULL)
{
ERR_ALLOC
}
- else for (size_t i = 0; i < slist->len; i++)
+ else for (i = 0; i < slist->len; i++)
{
series = (siridb_series_t *) slist->data[i];
if (shard->id % siridb->duration_num == series->mask)
return 0;
}
- len = *((uint16_t *) (pt + (is_ts64 ? 20 : 12))); // LEN POS IN INDEX
+ len = *((uint16_t *) (pt + (is_ts64 ? 20 : 12))); /* LEN POS IN INDEX */
series = imap_get(siridb->series_map, series_id);
if (shard->tp == SIRIDB_SHARD_TP_LOG)
if (siridb_series_add_idx(
series,
shard,
- is_ts64 ? // START_TS IN HEADER
+ is_ts64 ? /* START_TS IN HEADER */
(uint64_t) *((uint64_t *) (pt + 4)) :
(uint64_t) *((uint32_t *) (pt + 4)),
- is_ts64 ? // END_TS IN HEADER
+ is_ts64 ? /* END_TS IN HEADER */
(uint64_t) *((uint64_t *) (pt + 12)) :
(uint64_t) *((uint32_t *) (pt + 8)),
(uint32_t) pos,
return -1;
}
- rc = fseeko(fp, sz, SEEK_CUR); // 16 = NUM64 point size
+ rc = fseeko(fp, sz, SEEK_CUR); /* 16 = NUM64 point size */
if (rc != 0)
{
log_error(
*/
static bool is_temp_fn(const char * fn)
{
- for (int i = 0; i < 2; i++, fn++)
+ int i;
+ for (i = 0; i < 2; i++, fn++)
{
if (*fn != '_')
{
{
if ((user->access_bit & access_bit) == access_bit)
{
- return 1; // true
+ return 1; /* true */
}
char buffer[SIRIDB_ACCESS_STR_MAX];
user->name,
buffer);
- return 0; // false
+ return 0; /* false */
}
int siridb_user_cexpr_cb(siridb_user_t * user, cexpr_condition_t * cond)
{
double mean = 0.0;
double variance = 0.0;
+ size_t i;
switch (points->tp)
{
case TP_INT:
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
mean += (points->data + i)->val.int64;
}
mean /= points->len;
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
variance += pow(
(double) (points->data + i)->val.int64 - mean,
}
break;\
case TP_DOUBLE:
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
mean += (points->data + i)->val.real;
}
mean /= points->len;
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
variance += pow(
(points->data + i)->val.real - mean,
*/
void siri_fh_free(siri_fh_t * fh)
{
+ siri_fp_t ** fp;
+ uint16_t i;
+
if (fh == NULL)
{
return;
}
- siri_fp_t ** fp;
- for (uint16_t i = 0; i < fh->size; i++)
+ for (i = 0; i < fh->size; i++)
{
fp = fh->fpointers + i;
*/
void siri_help_free(void)
{
+ uint_fast16_t i;
+
#if DEBUG
log_debug("Free help");
#endif
- for (uint_fast16_t i = 0; i < HELP_COUNT; i ++)
+ for (i = 0; i < HELP_COUNT; i ++)
{
free(siri_help_content[i]);
}
#define POOL_ERR_MSG \
"At least one pool has no server available to process the request"
-#define POOL_ERR_LEN 64 // exact length of POOL_ERR_MSG
+#define POOL_ERR_LEN 64 /* exact length of POOL_ERR_MSG */
int sirinet_clserver_init(siri_t * siri)
sirinet_promise_t * promise;
size_t err_count = 0;
char err_msg[SIRIDB_MAX_SIZE_ERR_MSG];
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
if (promise == NULL)
void sirinet_promises_llist_free(slist_t * promises)
{
sirinet_promise_t * promise;
- for (size_t i = 0; i < promises->len; i++)
+ size_t i;
+
+ for (i = 0; i < promises->len; i++)
{
promise = (sirinet_promise_t *) promises->data[i];
if (promise != NULL)
#include <stdlib.h>
#include <string.h>
-#define MAX_ALLOWED_PKG_SIZE 20971520 // 20 MB
+#define MAX_ALLOWED_PKG_SIZE 20971520 /* 20 MB */
#define QUIT_SOCKET \
- free(ssocket->buf); \
+ free(ssocket->buf); \
ssocket->buf = NULL; \
- ssocket->len = 0; \
- ssocket->size = 0; \
+ ssocket->len = 0; \
+ ssocket->size = 0; \
ssocket->on_data = NULL; \
- sirinet_socket_decref(client); \
+ sirinet_socket_decref(client); \
return;
/* dns_req_family_map maps to IP_SUPPORT values defined in socket.h */
switch (ssocket->tp)
{
- case SOCKET_CLIENT: // listens to client connections
+ case SOCKET_CLIENT: /* listens to client connections */
if (ssocket->origin != NULL)
{
siridb_user_t * user = (siridb_user_t *) ssocket->origin;
siridb_user_decref(user);
}
break;
- case SOCKET_BACKEND: // listens to server connections
+ case SOCKET_BACKEND: /* listens to server connections */
if (ssocket->origin != NULL)
{
siridb_server_t * server = (siridb_server_t *) ssocket->origin;
siridb_server_decref(server);
}
break;
- case SOCKET_SERVER: // a server connection
+ case SOCKET_SERVER: /* a server connection */
{
siridb_server_t * server = (siridb_server_t *) ssocket->origin;
server->socket = NULL;
siridb_server_decref(server);
}
break;
- case SOCKET_MANAGE: // a server manage connection
+ case SOCKET_MANAGE: /* a server manage connection */
siri_admin_client_free((siri_admin_client_t *) ssocket->origin);
siri.socket = NULL;
break;
siridb_t * siridb;
siridb_shard_t * shard;
uint8_t c = siri.cfg->shard_compression;
+ size_t i;
log_info("Start optimize task");
slsiridb = llist2slist(siri.siridb_list);
if (slsiridb != NULL)
{
- for (size_t i = 0; i < slsiridb->len; i++)
+ for (i = 0; i < slsiridb->len; i++)
{
siridb = (siridb_t *) slsiridb->data[i];
siridb_incref(siridb);
return;
}
- for (size_t i = 0; i < slsiridb->len; i++)
+ for (i = 0; i < slsiridb->len; i++)
{
+ size_t j;
siridb = (siridb_t *) slsiridb->data[i];
#if DEBUG
sleep(1);
- for (size_t i = 0; i < slshards->len; i++)
+ for (j = 0; j < slshards->len; j++)
{
- shard = (siridb_shard_t *) slshards->data[i];
+ shard = (siridb_shard_t *) slshards->data[j];
if (!siri_err &&
optimize.status != SIRI_OPTIMIZE_CANCELLED &&
if (slsiridb != NULL)
{
siridb_t * siridb;
- for (size_t i = 0; i < slsiridb->len; i++)
+ size_t i;
+
+ for (i = 0; i < slsiridb->len; i++)
{
siridb = (siridb_t *) slsiridb->data[i];
siridb_decref(siridb);
#include <sys/time.h>
-#define MAX_ITERATE_COUNT 10000 // ten-thousand
-#define MAX_BATCH_REQUIRE_SHARD 100 // after reading 100 shards, iterate
+#define MAX_ITERATE_COUNT 10000 /* ten-thousand */
+#define MAX_BATCH_REQUIRE_SHARD 100 /* after reading 100 shards, iterate */
#define QP_ADD_SUCCESS qp_add_raw( \
query->packer, (const unsigned char *) "success_msg", 11);
void siriparser_init_listener(void)
{
- for (uint_fast16_t i = 0; i < CLERI_END; i++)
+ uint_fast16_t i;
+
+ for (i = 0; i < CLERI_END; i++)
{
siriparser_listen_enter[i] = NULL;
siriparser_listen_exit[i] = NULL;
siriparser_listen_exit[CLERI_GID_SHOW_STMT] = exit_show_stmt;
siriparser_listen_exit[CLERI_GID_TIMEIT_STMT] = exit_timeit_stmt;
- for (uint_fast16_t i = HELP_OFFSET; i < HELP_OFFSET + HELP_COUNT; i++)
+ for (i = HELP_OFFSET; i < HELP_OFFSET + HELP_COUNT; i++)
{
siriparser_listen_exit[i] = exit_help_xxx;
}
else
{
siridb_series_t * series;
+ size_t i;
q_wrapper->series_tmp = (q_wrapper->update_cb == NULL) ?
q_wrapper->series_map : imap_new();
uv_mutex_lock(&siridb->groups->mutex);
- for (size_t i = 0; i < group->series->len; i++)
+ for (i = 0; i < group->series->len; i++)
{
series = (siridb_series_t *) group->series->data[i];
siridb_series_incref(series);
if (q_count->where_expr == NULL)
{
+ size_t i;
+ slist_t * slist;
+ siridb_series_t * series;
+
uv_mutex_lock(&siridb->series_mutex);
- slist_t * slist = imap_2slist((q_count->series_map == NULL) ?
+ slist = imap_2slist((q_count->series_map == NULL) ?
siridb->series_map : q_count->series_map);
uv_mutex_unlock(&siridb->series_mutex);
MEM_ERR_RET
}
- siridb_series_t * series;
-
- for (size_t i = 0; i < slist->len; i++)
+ for (i = 0; i < slist->len; i++)
{
series = (siridb_series_t *) slist->data[i];
q_count->n += series->length;
}
else
{
+ uv_async_t * next;
+
uv_mutex_lock(&siridb->series_mutex);
q_count->slist = imap_2slist_ref(
MEM_ERR_RET
}
- uv_async_t * next =
- (uv_async_t *) malloc(sizeof(uv_async_t));
+ next = (uv_async_t *) malloc(sizeof(uv_async_t));
if (next == NULL)
{
query_count_t * q_count = (query_count_t *) query->data;
cexpr_t * where_expr = q_count->where_expr;
cexpr_cb_t cb = (cexpr_cb_t) siridb_server_cexpr_cb;
+ int is_local = IS_MASTER;
qp_add_raw(query->packer, (const unsigned char *) "servers", 7);
- int is_local = IS_MASTER;
/* if is_local, check if we use 'remote' props in where expression */
if (is_local && where_expr != NULL)
if (is_local)
{
- for ( llist_node_t * node = siridb->servers->first;
+ llist_node_t * node;
+ for ( node = siridb->servers->first;
node != NULL;
node = node->next)
{
siridb_shard_view_t vshard = {
.server=siridb->server
};
+ size_t i;
+ slist_t * shards_list;
uv_mutex_lock(&siridb->shards_mutex);
- slist_t * shards_list = imap_2slist_ref(siridb->shards);
+ shards_list = imap_2slist_ref(siridb->shards);
uv_mutex_unlock(&siridb->shards_mutex);
MEM_ERR_RET
}
- for (size_t i = 0; i < shards_list->len; i++)
+ for (i = 0; i < shards_list->len; i++)
{
vshard.shard = (siridb_shard_t *) shards_list->data[i];
siridb_t * siridb = ((sirinet_socket_t *) query->client->data)->siridb;
query_count_t * q_count = (query_count_t *) query->data;
uint64_t duration;
-
- qp_add_raw(query->packer, (const unsigned char *) "shards_size", 11);
-
+ size_t i;
+ slist_t * shards_list;
siridb_shard_view_t vshard = {
.server=siridb->server
};
+ qp_add_raw(query->packer, (const unsigned char *) "shards_size", 11);
+
uv_mutex_lock(&siridb->shards_mutex);
- slist_t * shards_list = imap_2slist_ref(siridb->shards);
+ shards_list = imap_2slist_ref(siridb->shards);
uv_mutex_unlock(&siridb->shards_mutex);
MEM_ERR_RET
}
- for (size_t i = 0; i < shards_list->len; i++)
+ for (i = 0; i < shards_list->len; i++)
{
vshard.shard = (siridb_shard_t *) shards_list->data[i];
siridb_shard_view_t vshard = {
.server=siridb->server
};
-
size_t dropped = 0;
+ size_t i;
- for (size_t i = 0; i < q_drop->shards_list->len; i++)
+ for (i = 0; i < q_drop->shards_list->len; i++)
{
vshard.shard = (siridb_shard_t *) q_drop->shards_list->data[i];
}
else
{
+ uv_async_t * next;
+
QP_ADD_SUCCESS
q_drop->n = q_drop->shards_list->len;
- uv_async_t * next = (uv_async_t *) malloc(sizeof(uv_async_t));
+ next = (uv_async_t *) malloc(sizeof(uv_async_t));
if (next == NULL)
{
if (!is_local)
{
is_local = 1;
- for (size_t i = 0; i < q_list->props->len; i++)
+ size_t i;
+ for (i = 0; i < q_list->props->len; i++)
{
if (siridb_group_is_remote_prop(
*((uint32_t *) q_list->props->data[i])))
/* if is_local, check if we need ask for 'remote' columns */
if (is_local && q_list->props != NULL)
{
- for (size_t i = 0; i < q_list->props->len; i++)
+ size_t i;
+ for (i = 0; i < q_list->props->len; i++)
{
if (siridb_server_is_remote_prop(
*((uint32_t *) q_list->props->data[i])))
siridb_shard_view_t vshard = {
.server=siridb->server
};
+ size_t i;
+ slist_t * shards_list;
uv_mutex_lock(&siridb->shards_mutex);
- slist_t * shards_list = imap_2slist_ref(siridb->shards);
+ shards_list = imap_2slist_ref(siridb->shards);
uv_mutex_unlock(&siridb->shards_mutex);
qp_add_raw(query->packer, (const unsigned char *) "shards", 6);
qp_add_type(query->packer, QP_ARRAY_OPEN);
- for (size_t i = 0; i < shards_list->len; i++)
+ for (i = 0; i < shards_list->len; i++)
{
vshard.shard = (siridb_shard_t *) shards_list->data[i];
cexpr_cb_t cb = (cexpr_cb_t) siridb_user_cexpr_cb;
query_list_t * q_list = (query_list_t *) query->data;
cexpr_t * where_expr = q_list->where_expr;
-
size_t i;
siridb_user_t * user;
if (points != NULL)
{
const char * name;
+ size_t i;
- for (size_t i = 1; points->len && i < q_select->alist->len; i++)
+ for (i = 1; points->len && i < q_select->alist->len; i++)
{
aggr_points = siridb_aggregate_run(
points,
if (points != NULL)
{
const char * name;
+ size_t i;
- for (size_t i = 0; points->len && i < q_select->alist->len; i++)
+ for (i = 0; points->len && i < q_select->alist->len; i++)
{
aggr_points = siridb_aggregate_run(
points,
q_wrapper->regex,
(PCRE2_SPTR8) series->name,
series->name_len,
- 0, // start looking at this point
- 0, // OPTIONS
+ 0, /* start looking at this point */
+ 0, /* OPTIONS */
q_wrapper->match_data,
- 0); // length of sub_str_vec
+ 0); /* length of sub_str_vec */
if ( pcre_exec_ret < 0 ||
imap_add(q_wrapper->series_tmp, series->id, series))
{
sirinet_promise_t * promise;
qp_unpacker_t unpacker;
qp_obj_t qp_count;
-
query_alter_t * q_alter = (query_alter_t *) query->data;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if ( qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // servers etc.
- qp_is_int(qp_next(&unpacker, &qp_count))) // one result
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* servers etc.*/
+ qp_is_int(qp_next(&unpacker, &qp_count))) /* one result*/
{
q_alter->n += qp_count.via.int64;
sirinet_promise_t * promise;
qp_unpacker_t unpacker;
qp_obj_t qp_count;
-
query_count_t * q_count = (query_count_t *) query->data;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if ( qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // servers etc.
- qp_is_int(qp_next(&unpacker, &qp_count))) // one result
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* servers etc.*/
+ qp_is_int(qp_next(&unpacker, &qp_count))) /* one result*/
{
q_count->n += qp_count.via.int64;
sirinet_promise_t * promise;
qp_unpacker_t unpacker;
qp_obj_t qp_drop;
-
query_drop_t * q_drop = (query_drop_t *) query->data;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if ( qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // servers etc.
- qp_is_int(qp_next(&unpacker, &qp_drop))) // one result
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* servers etc.*/
+ qp_is_int(qp_next(&unpacker, &qp_drop))) /* one result */
{
q_drop->n += qp_drop.via.int64;
sirinet_promise_t * promise;
qp_unpacker_t unpacker;
qp_obj_t qp_drop;
-
query_drop_t * q_drop = (query_drop_t *) query->data;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if ( qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // shards
- qp_is_int(qp_next(&unpacker, &qp_drop))) // one result
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* shards */
+ qp_is_int(qp_next(&unpacker, &qp_drop))) /* one result */
{
q_drop->n += qp_drop.via.int64;
siridb_group_t * group;
qp_obj_t qp_name;
qp_obj_t qp_series;
+ size_t i;
siridb_groups_init_nseries(siridb->groups);
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_t unpacker;
siridb_query_t * query = (siridb_query_t *) handle->data;
query_list_t * q_list = (query_list_t *) query->data;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if ( qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // columns
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* columns */
qp_is_array(qp_skip_next(&unpacker)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // series/...
- qp_is_array(qp_next(&unpacker, NULL))) // results
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* series/... */
+ qp_is_array(qp_next(&unpacker, NULL))) /* results */
{
while (qp_is_array(qp_current(&unpacker)))
{
qp_obj_t qp_len;
qp_obj_t qp_points;
qp_obj_t qp_err_msg;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
qp_unpacker_init(&unpacker, pkg->data, pkg->len);
if ( qp_is_map(qp_next(&unpacker, NULL)) &&
- qp_is_raw(qp_next(&unpacker, NULL)) && // select
+ qp_is_raw(qp_next(&unpacker, NULL)) && /* select */
qp_is_map(qp_next(&unpacker, NULL)))
{
if (q_select->merge_as == NULL)
}
else
{
+ uv_async_t * next;
uv_work_t * work = (uv_work_t *) malloc(sizeof(uv_work_t));
if (work == NULL)
{
MEM_ERR_RET
}
- uv_async_t * next = (uv_async_t *) malloc(sizeof(uv_async_t));
+ next = (uv_async_t *) malloc(sizeof(uv_async_t));
if (next == NULL)
{
free(work);
sirinet_promise_t * promise;
siridb_query_t * query = (siridb_query_t *) handle->data;
size_t err_count = 0;
+ size_t i;
- for (size_t i = 0; i < promises->len; i++)
+ for (i = 0; i < promises->len; i++)
{
promise = promises->data[i];
if (q_select->mlist != NULL && points != NULL)
{
siridb_points_t * aggr_points;
- for (size_t i = 0; points->len && i < q_select->mlist->len; i++)
+ size_t i;
+
+ for (i = 0; points->len && i < q_select->mlist->len; i++)
{
aggr_points = siridb_aggregate_run(
points,
if (aggr_points == NULL)
{
- return -1; // (error message is set)
+ return -1; /* (error message is set) */
}
points = aggr_points;
slist_t * plist,
uv_async_t * handle)
{
+ size_t i;
siridb_query_t * query = (siridb_query_t *) handle->data;
int rc = qp_add_raw_term(
query->packer, (const unsigned char *) name, len) ||
qp_add_type(query->packer, QP_ARRAY_OPEN);
- for (size_t i = 0; !rc && i < plist->len; i++)
+ for (i = 0; !rc && i < plist->len; i++)
{
rc = siridb_points_raw_pack(
(siridb_points_t * ) plist->data[i],
}
}
- qp_next(unpacker, NULL); // QP_ARRAY_CLOSE
+ qp_next(unpacker, NULL); /* QP_ARRAY_CLOSE */
}
}
}
}
- qp_next(unpacker, NULL); // QP_ARRAY_CLOSE
+ qp_next(unpacker, NULL); /* QP_ARRAY_CLOSE */
}
}
}
if (where_expr == NULL || cexpr_run(where_expr, cb, group))
{
+ size_t i;
qp_add_type(query->packer, QP_ARRAY_OPEN);
- for (size_t i = 0; i < props->len; i++)
+ for (i = 0; i < props->len; i++)
{
siridb_group_prop(
group,
q_select->presuf = NULL;
q_select->merge_as = NULL;
q_select->n = 0;
- q_select->nselects = 1; // we have at least one select function
+ q_select->nselects = 1; /* we have at least one select function */
q_select->points_map = NULL;
q_select->alist = NULL;
q_select->mlist = NULL;
static void QUERIES_free_merge_result(slist_t * plist)
{
- for (size_t i = 0; i < plist->len; i ++)
+ size_t i;
+ for (i = 0; i < plist->len; i ++)
{
siridb_points_free(plist->data[i]);
}
#define WAIT_BETWEEN_CLOSE_ATTEMPTS 3000
static uv_timer_t closing_timer;
-static int closing_attempts = 40; // times 3 seconds is 2 minutes
+static int closing_attempts = 40; /* times 3 seconds is 2 minutes */
#define N_SIGNALS 6
static int signals[N_SIGNALS] = {
struct timespec start;
struct timespec end;
uv_signal_t sig[N_SIGNALS];
+ int i;
/* get start time so we can calculate the startup_time */
clock_gettime(CLOCK_MONOTONIC, &start);
SIRI_destroy();
free(siri.loop);
siri.loop = NULL;
- return rc; // something went wrong
+ return rc; /* something went wrong */
}
/* bind signals to the event loop */
- for (int i = 0; i < N_SIGNALS; i++)
+ for (i = 0; i < N_SIGNALS; i++)
{
uv_signal_init(siri.loop, &sig[i]);
uv_signal_start(&sig[i], SIRI_signal_handler, signals[i]);
{
int rc;
rc = uv_loop_close(siri.loop);
- if (rc) // could be UV_EBUSY (-16) in case handlers are not closed yet
+ if (rc) /* could be UV_EBUSY (-16) in case handlers are not closed */
{
log_error("Error occurred while closing the event loop: %d", rc);
}
*/
char * end;
- // trim leading chars
+ /* trim leading chars */
while ((chr && **str == chr) || (!chr && isspace(**str)))
{
(*str)++;
}
- // check all chars?
+ /* check all chars? */
if(**str == 0)
{
return;
}
- // trim trailing chars
+ /* trim trailing chars */
end = *str + strlen(*str) - 1;
while (end > *str &&
((chr && *end == chr) || (!chr && isspace(*end))))
end--;
}
- // write new null terminator
+ /* write new null terminator */
*(end + 1) = 0;
}
bool strx_is_int(const char * str)
{
- // Handle negative numbers.
+ /* Handle negative numbers. */
if (*str == '-')
{
++str;
}
- // Handle empty string or just "-".
+ /* Handle empty string or just "-". */
if (!*str)
{
return false;
}
- // Check for non-digit chars in the rest of the string.
+ /* Check for non-digit chars in the rest of the string. */
while (*str)
{
if (!isdigit(*str))
bool strx_is_float(const char * str)
{
- // Handle negative numbers.
+ /* Handle negative numbers. */
if (*str == '-' || *str == '+')
{
++str;
size_t dots = 0;
- // Handle empty string or just "-".
+ /* Handle empty string or just "-". */
if (!*str)
{
return false;
}
- // Check for non-digit chars in the rest of the string.
+ /* Check for non-digit chars in the rest of the string. */
while (*str)
{
if (*str == '.')
test_start("Testing ctree");
ct_t * ct = ct_new();
- // first add should be successful
+ /* first add should be successful */
assert (ct_add(ct, "Iris", "is gewoon Iris") == CT_OK);
assert (ct_add(ct, "Iris1", "is gewoon Iris1") == CT_OK);
assert (ct_add(ct, "Iris2", "is gewoon Iris2") == CT_OK);
- // key exists
+ /* key exists */
assert (ct_add(ct, "Iris", "Iris?") == CT_EXISTS);
- // len should be 3 by now
+ /* len should be 3 by now */
assert (ct->len == 3);
assert (strcmp(ct_getn(ct, "Iris1!", 5), "is gewoon Iris1") == 0);
assert (strcmp(ct_get(ct, "Iris"), "is gewoon Iris") == 0);
static int test_gen_pool_lookup(void)
{
- test_start("Testing test_gen_pool_lookup");
-
- siridb_lookup_t * lookup = siridb_lookup_new(4);
+ int i;
+ siridb_lookup_t * lookup;
uint16_t match[30] = {
0, 1, 0, 2, 3, 1, 0, 3, 3, 2, 2, 1, 0, 1, 0,
2, 3, 1, 0, 3, 3, 2, 2, 1, 0, 1, 0, 2, 3, 1};
- for (int i = 0; i < 30; i++)
+ test_start("Testing test_gen_pool_lookup");
+
+ lookup = siridb_lookup_new(4);
+
+ for (i = 0; i < 30; i++)
assert(match[i] == (*lookup)[i]);
free(lookup);
qp_via_t val;
uint64_t timestamps[5] = {4, 6, 3, 5, 7};
int64_t values[5] = {1, 3, 0, 2, 4};
+ size_t i;
- for (int i = 0; i < 5; i++)
+ for (i = 0; i < 5; i++)
{
val.int64 = values[i];
siridb_points_add_point(points, ×tamps[i], &val);
}
- for (size_t i = 0; i < points->len; i++)
+ for (i = 0; i < points->len; i++)
{
point = points->data + i;
assert (i == (size_t) point->val.int64);
projects / siridb-server.git / commitdiff